"""
TodoLog DAO层（数据访问对象）
负责todo_log表的增删改查操作，所有方法返回格式统一为 (bool, result)
- 成功：(True, 结果数据/None)
- 失败：(False, 错误信息字符串)
"""
from app.Models.Todo.TodoLogModel import TodoLog
from app.db import db
from sqlalchemy.exc import SQLAlchemyError
import datetime


class TodoLogDAO:
    @staticmethod
    def create_todo_log(todo_log_dict):
        """
        创建新的Todo日志记录
        :param todo_log_dict: 日志信息字典，需包含以下键：
            - user_id: 用户ID
            - task_id: 关联的主任务ID
            - description: 日志描述（必填）
            - self_score: 自我评分（必填）
            - log_title: 日志标题（可选）
            - focus_time: 专注时长（可选，默认0）
            - submit_time: 提交时间（可选，默认当前时间）
        :return: (bool, result)
            成功：(True, 创建的TodoLog对象)
            失败：(False, 错误信息)
        """
        try:
            # 构建TodoLog对象
            todo_log = TodoLog(
                user_id=todo_log_dict.get('user_id'),
                task_id=todo_log_dict.get('task_id'),
                log_title=todo_log_dict.get('log_title', ''),  # 默认为空字符串
                description=todo_log_dict['description'],  # 必填项，直接取值
                self_score=todo_log_dict['self_score'],  # 必填项，直接取值
                focus_time=todo_log_dict.get('focus_time', 0),  # 默认为0
                submit_time=todo_log_dict.get('submit_time', datetime.datetime.now()),
                attachment=todo_log_dict.get('attachment', '')
            )

            # 提交到数据库
            db.session.add(todo_log)
            db.session.commit()
            return True, todo_log
        except KeyError as e:
            # 缺少必填字段
            db.session.rollback()
            return False, f"创建失败：缺少必填字段 {str(e)}"
        except SQLAlchemyError as e:
            # 数据库操作异常
            db.session.rollback()
            return False, f"创建失败：数据库错误 - {str(e)}"
        except Exception as e:
            # 其他未知异常
            db.session.rollback()
            return False, f"创建失败：未知错误 - {str(e)}"

    @staticmethod
    def get_todo_log_by_id(log_id):
        """
        根据日志ID查询单条日志记录
        :param log_id: 日志主键ID
        :return: (bool, result)
            成功（存在）：(True, TodoLog对象)
            成功（不存在）：(True, None)
            失败：(False, 错误信息)
        """
        try:
            todo_log = TodoLog.query.filter_by(id=log_id).first()
            return True, todo_log
        except SQLAlchemyError as e:
            return False, f"查询失败：数据库错误 - {str(e)}"
        except Exception as e:
            return False, f"查询失败：未知错误 - {str(e)}"

    @staticmethod
    def get_todo_logs_by_condition(**kwargs):
        """
        根据条件查询日志列表（支持多条件组合）
        :param kwargs: 查询条件，可选键：
            - user_id: 用户ID
            - task_id: 主任务ID
            - self_score: 自我评分
            - submit_time_start: 提交时间起始（datetime对象）
            - submit_time_end: 提交时间结束（datetime对象）
            - page: 页码（默认1）
            - per_page: 每页条数（默认20）
        :return: (bool, result)
            成功：(True, 分页对象Pagination)
            失败：(False, 错误信息)
        """
        try:
            # 构建查询条件
            query = TodoLog.query

            # 精确匹配条件
            if 'user_id' in kwargs:
                query = query.filter_by(user_id=kwargs['user_id'])
            if 'task_id' in kwargs:
                query = query.filter_by(task_id=kwargs['task_id'])
            if 'self_score' in kwargs:
                query = query.filter_by(self_score=kwargs['self_score'])

            # 时间范围条件
            if 'submit_time_start' in kwargs:
                query = query.filter(TodoLog.submit_time >= kwargs['submit_time_start'])
            if 'submit_time_end' in kwargs:
                query = query.filter(TodoLog.submit_time <= kwargs['submit_time_end'])

            # 分页参数
            page = kwargs.get('page', 1)
            per_page = kwargs.get('per_page', 20)

            # 执行分页查询（按提交时间倒序）
            pagination = query.order_by(TodoLog.submit_time.desc()).paginate(
                page=page, per_page=per_page, error_out=False
            )
            return True, pagination
        except SQLAlchemyError as e:
            return False, f"查询列表失败：数据库错误 - {str(e)}"
        except Exception as e:
            return False, f"查询列表失败：未知错误 - {str(e)}"

    @staticmethod
    def update_todo_log(log_id, update_dict):
        """
        根据日志ID更新日志信息
        :param log_id: 要更新的日志ID
        :param update_dict: 要更新的字段字典，可选键：
            - log_title: 日志标题
            - description: 日志描述
            - self_score: 自我评分
            - focus_time: 专注时长
            - submit_time: 提交时间
        :return: (bool, result)
            成功（存在并更新）：(True, 更新后的TodoLog对象)
            成功（不存在）：(True, None)
            失败：(False, 错误信息)
        """
        try:
            # 查询日志是否存在
            todo_log = TodoLog.query.filter_by(id=log_id).first()
            if not todo_log:
                return True, None

            # 更新字段（只更新传入的有效字段）
            for key, value in update_dict.items():
                if hasattr(todo_log, key) and key not in ['id', 'user_id', 'task_id']:  # 不允许更新主键和关联ID
                    setattr(todo_log, key, value)

            # 提交更新
            db.session.commit()
            return True, todo_log
        except SQLAlchemyError as e:
            db.session.rollback()
            return False, f"更新失败：数据库错误 - {str(e)}"
        except Exception as e:
            db.session.rollback()
            return False, f"更新失败：未知错误 - {str(e)}"

    @staticmethod
    def delete_todo_log(log_id):
        """
        根据日志ID删除日志记录
        :param log_id: 要删除的日志ID
        :return: (bool, result)
            成功（存在并删除）：(True, None)
            成功（不存在）：(True, None)
            失败：(False, 错误信息)
        """
        try:
            # 查询日志是否存在
            todo_log = TodoLog.query.filter_by(id=log_id).first()
            if todo_log:
                db.session.delete(todo_log)
                db.session.commit()
            print(todo_log.id)
            return True, todo_log
        except SQLAlchemyError as e:
            db.session.rollback()
            return False, f"删除失败：数据库错误 - {str(e)}"
        except Exception as e:
            db.session.rollback()
            return False, f"删除失败：未知错误 - {str(e)}"

    @staticmethod
    def delete_todo_logs_by_task_id(task_id):
        """
        根据主任务ID批量删除关联的日志记录（级联删除辅助方法）
        :param task_id: 主任务ID
        :return: (bool, result)
            成功：(True, 删除的记录数)
            失败：(False, 错误信息)
        """
        try:
            # 执行批量删除
            delete_count = TodoLog.query.filter_by(task_id=task_id).delete()
            db.session.commit()
            return True, delete_count
        except SQLAlchemyError as e:
            db.session.rollback()
            return False, f"批量删除失败：数据库错误 - {str(e)}"
        except Exception as e:
            db.session.rollback()
            return False, f"批量删除失败：未知错误 - {str(e)}"
